Come modificare i messaggi di commit esistenti, non premuti?

Modifica del messaggio di commit più recente
git commit --amend
aprirà il tuo editor, permettendoti di cambiare il messaggio di commit del commit più recente. Inoltre, puoi impostare il messaggio di commit direttamente nella riga di comando con:
git commit --amend -m "Nuovo messaggio di commit"
... tuttavia, questo può rendere i messaggi di commit su più righe o piccole correzioni più complicati da inserire.
Assicurati di non avere nessuna modifica alla copia di lavoro messa in scena prima di farlo o anche loro verranno impegnate. (Le modifiche non organizzate non verranno applicate.)
Modifica del messaggio di un commit che hai già inviato al tuo ramo remoto
Se hai già eseguito il push del commit sul tuo ramo remoto, dopo aver modificato il tuo commit localmente (come descritto sopra), dovrai anche forzare il push del commit con:
git push   --force
# O
git push   -f
Attenzione: il push forzato sovrascriverà il ramo remoto con lo stato del tuo locale. Se ci sono commit sul ramo remoto che non hai nel ramo locale, perderai quei commit.
Attenzione: sii cauto nel modificare i commit che hai già condiviso con altre persone. La modifica dei commit essenzialmente li riscrive per avere ID SHA diversi, il che pone un problema se altre persone hanno copie del vecchio commit che hai riscritto. Chiunque abbia una copia del vecchio commit dovrà sincronizzare il proprio lavoro con il commit appena riscritto, il che a volte può essere difficile, quindi assicurati di coordinarti con gli altri quando tenti di riscrivere la cronologia dei commit condivisi, o semplicemente evitare di riscrivere i commit condivisi del tutto.
Esegui un rebase interattivo
Un'altra opzione è usare il rebase interattivo.
Ciò ti consente di modificare qualsiasi messaggio che desideri aggiornare anche se non è l'ultimo messaggio.
Per fare uno squash Git, segui questi passaggi:
// n è il numero di commit fino all'ultimo commit che desideri poter modificare
git rebase -i HEAD ~ n
Dopo aver annullato i commit, scegli l'e / r per modificare il messaggio:
Nota importante sul rebase interattivo
Quando usi git rebase -i HEAD ~ n ci possono essere più di n commit. Git "raccoglierà" tutti i commit negli ultimi n commit, e se ci fosse una fusione da qualche parte tra quell'intervallo vedrai anche tutti i commit, quindi il risultato sarà n +.
Buona dritta:
Se devi farlo per più di un singolo ramo e potresti incontrare conflitti durante la modifica del contenuto, imposta git rerere e lascia che Git risolva quei conflitti automaticamente per te.
Documentazione
git-commit (1) Pagina manuale
git-rebase (1) Pagina manuale
git-push (1) Pagina manuale
|
git commit --amend -m "il tuo nuovo messaggio"
|
Se il commit che desideri correggere non è il più recente:
git rebase --interactive $ parent_of_flawed_commit
Se desideri correggere diversi commit errati, passa il genitore del più vecchio di essi.
Verrà visualizzato un editor, con un elenco di tutti i commit a partire da quello che hai fornito.
Cambia la scelta per riformulare (o nelle vecchie versioni di Git, per modificare) davanti a qualsiasi commit che desideri correggere.
Una volta salvato, Git riprodurrà i commit elencati.
Per ogni commit che vuoi riformulare, Git ti riporterà nel tuo editor. Per ogni commit che vuoi modificare, Git ti inserisce nella shell. Se sei nella shell:
Cambia il commit nel modo che preferisci.
git commit --amend
git rebase --continue
La maggior parte di questa sequenza ti verrà spiegata dall'output dei vari comandi mentre procedi. È molto facile; non è necessario memorizzarlo - ricorda solo che git rebase --interactive ti consente di correggere i commit indipendentemente da quanto tempo erano.
Nota che non vorrai modificare i commit che hai già inviato. O forse lo fai, ma in quel caso dovrai fare molta attenzione a comunicare con tutti coloro che potrebbero aver recuperato i tuoi impegni e lavorato su di essi. Come faccio a ripristinare / risincronizzare dopo che qualcuno ha inviato un rebase o un ripristino a un ramo pubblicato?
|
Per modificare il commit precedente, apportare le modifiche desiderate e mettere in scena tali modifiche, quindi eseguire
git commit --amend
Questo aprirà un file nel tuo editor di testo che rappresenta il tuo nuovo messaggio di commit. Inizia popolato con il testo del tuo vecchio messaggio di commit. Modifica il messaggio di commit come desideri, quindi salva il file e chiudi l'editor per terminare.
Per modificare il commit precedente e mantenere lo stesso messaggio di log, esegui
git commit --amend -C HEAD
Per correggere il commit precedente rimuovendolo completamente, esegui
git reset --hard HEAD ^
Se vuoi modificare più di un messaggio di commit, esegui
git rebase -i HEAD ~ commit_count
(Sostituisci commit_count con il numero di commit che desideri modificare.) Questo comando avvia l'editor. Contrassegna il primo commit (quello che desideri modificare) come "modifica" invece di "seleziona", quindi salva ed esci dall'editor. Apporta la modifica che desideri eseguire il commit e quindi esegui
git commit --amend
git rebase --continue
Nota: puoi anche "Apportare la modifica che desideri" dall'editor aperto da git commit --amend
|
Come giàmenzionato, git commit --amend è il modo per sovrascrivere l'ultimo commit. Una nota: se vuoi sovrascrivere anche i file, il comando sarebbe
git commit -a --amend -m "Il mio nuovo messaggio di commit"
|
Puoi anche usare git filter-branch per questo.
git filter-branch -f --msg-filter "sed 's / errror / error /'" $ flawed_commit..HEAD
Non è facile come un banale commit git --amend, ma è particolarmente utile se hai già delle unioni dopo il tuo messaggio di commit errato.
Nota che questo proverà a riscrivere ogni commit tra HEAD e il commit difettoso, quindi dovresti scegliere il tuo comando msg-filter molto saggiamente ;-)
|
Preferisco così:
git commit --amend -c 
Altrimenti, ci sarà un nuovo commit con un nuovo ID commit.
|
Se stai usando lo strumento Git GUI, c'è un pulsante chiamato Modifica ultimo commit. Fare clic su quel pulsante e quindi verranno visualizzati i file e il messaggio dell'ultimo commit. Basta modificare quel messaggio e puoi eseguirne il commit con un nuovo messaggio di commit.
Oppure usa questo comando da una console / terminale:
git commit -a --amend -m "Il mio nuovo messaggio di commit"
|
Puoi usare Git rebasing. Ad esempio, se desideri modificare nuovamente per eseguire il commit bbc643cd, esegui
$ git rebase bbc643cd ^ --interactive
Nell'editor predefinito, modifica "pick" in "edit" nella riga di cui desideri modificare il commit. Apporta le modifiche e poi mettile in scena con
$ git add 
Ora puoi usare
$ git commit --amend
per modificare il commit e dopo
$ git rebase --continue
per tornare al precedente head commit.
|
Se vuoi solo modificare il tuo ultimo messaggio di commit, allora fai:
git commit --amend
Questo ti porterà nel tuo editor di testo e ti permetterà di cambiare l'ultimo messaggio di commit.
Se desideri modificare gli ultimi tre messaggi di commit o uno qualsiasi dei messaggi di commit fino a quel punto, fornisci HEAD ~ 3 al comando git rebase -i:
git rebase -i HEAD ~ 3
|
Se devi modificare un vecchio messaggio di commit su più rami (cioè, il commit con il messaggio errato è presente in più rami) potresti voler usare:
git filter-branch -f --msg-filter \
'sed "s /  /  / g"' - --all
Git creerà una directory temporanea per la riscrittura e in aggiunta il backup dei vecchi riferimenti in refs / original /.
-f imporrà l'esecuzione dell'operazione. Ciò è necessario se la directory temporanea è già presente o se ci sono già riferimenti memorizzati in refs / original. Se non è così, puoi eliminare questo flag.
- separa le opzioni del ramo di filtro dalle opzioni di revisione.
--all farà in modo che tutti i rami e i tag vengano riscritti.
A causa del backup dei tuoi vecchi riferimenti, puoi facilmente tornare allo stato prima di eseguire il comando.
Dì, vuoi recuperare il tuo master e accedervi nel ramo old_master:
git checkout -b old_master refs / original / refs / heads / master
|
Uso
git commit --amend
Per capirlo in dettaglio, un ottimo post è 4. Riscrivere la storia di Git. Parla anche di quando non usare git commit --amend.
|
Se è il tuo ultimo commit, modifica semplicemente il commit:
git commit --amend -o -m "Nuovo messaggio di commit"
(Utilizzando il flag -o (--only) per assicurarsi di modificare solo il messaggio di commit)
Se è un commit sepolto, usa il fantastico rebase interattivo:
git rebase -i @ ~ 9 # Mostra gli ultimi 9 commit in un editor di testo
Trova il commit che desideri, cambia pick in r (reword), salva e chiudi il file. Fatto!
Tutorial su Vim in miniatura (o, come rebase con solo 8 sequenze di tasti 3jcwrEscZZ):
Esegui vimtutor se hai tempo
hjkl corrispondono ai tasti di movimento ← ↓ ↑ →
Tutti i comandi possono essere preceduti da un "intervallo", ad es. 3j scende di tre righe
i per accedere alla modalità di inserimento: il testo digitato apparirà nel file
Esc o Ctrlc per uscire dalla modalità di inserimento e tornare alla modalità "normale"
u per annullare
Ctrlr da rifare
dd, dw, dl per eliminare rispettivamente una riga, una parola o una lettera
cc, cw, cl per cambiare rispettivamente una riga, una parola o una lettera (come ddi)
yy, yw, yl per copiare ("yank") rispettivamente una riga, una parola o una lettera
p o P per incollare dopo o prima della posizione corrente, rispettivamente
: wInvio per salvare (scrivere) un file
: q! Invio per uscire senza salvare
: wqEnter o ZZ per salvare e uscire
Se modifichi molto il testo, passa al layout di tastiera di Dvorak, impara a digitare e impara Vim. Ne vale la pena? Sì.
ProTip ™: non aver paura di sperimentare comandi "pericolosi" che riscrivono la cronologia * - Git non elimina i tuoi commit per 90 giorni per impostazione predefinita; li puoi trovare nel reflog:
$ git reset @ ~ 3 # Torna indietro di tre commit
$ git reflog
c4f708b HEAD @ {0}: reset: passaggio a @ ~ 3
2c52489 HEAD @ {1}: commit: più modifiche
4a5246d HEAD @ {2}: commit: apporta modifiche importanti
e8571e4 HEAD @ {3}: commit: apporta alcune modifiche
... precedenti commit ...
$ git reset 2c52489
... e sei tornato da dove hai iniziato
* Fai attenzione alle opzioni come --hard e --force però - possono scartare i dati.
* Inoltre, non riscrivere la cronologia sui rami su cui stai collaborando.
|
Modifica
Hai un paio diopzioni qui. Tu puoi fare
git commit --amend
fintanto che è il tuo ultimo impegno.
Rebase interattivo
Altrimenti, se non è il tuo ultimo commit, puoi fare un rebase interattivo,
git rebase -i [branched_from] [hash before commit]
Quindi, all'interno del rebase interattivo, aggiungi semplicemente la modifica a quel commit. Quando viene visualizzato, eseguire git commit --amend e modificare il messaggio di commit. Se vuoi eseguire il rollback prima di quel punto di commit, puoi anche usare git reflog ed eliminare semplicemente quel commit. Quindi fai di nuovo un commit git.
|
Se stai usando la GUI di Git, puoi modificare l'ultimo commit che non è stato inviato con:
Conferma / Modifica ultimo impegno
|
Uso la GUI di Git il più possibile e questo ti dà la possibilità di modificare l'ultimo commit:
Inoltre, git rebase -i origin / master è un bel mantra che ti presenterà sempre i commit che hai fatto sopra master e ti darà la possibilità di modificare, eliminare, riordinare o eliminare. Non c'è bisogno di procurarsi quell'hash prima.
|
Wow, quindi ci sono molti modi per farlo.
Un altro modo per farlo è eliminare l'ultimo commit, ma mantenere le sue modifiche in modo da non perdere il lavoro. È quindi possibile eseguire un altro commit con il messaggio corretto. Questo sarebbe simile a questo:
git reset --soft HEAD ~ 1
git commit -m 'Messaggio di commit nuovo e corretto'
Lo faccio sempre se dimentico di aggiungere un file o di apportare una modifica.
Ricorda di specificare --soft invece di --hard, altrimenti perdi completamente il commit.
|
Per chiunque cerchi una GUI Windows / Mac per aiutare a modificare i messaggi più vecchi (cioè non solo l'ultimo messaggio), consiglio Sourcetree. I passaggi da seguire sono sotto l'immagine.
Per i commit che non sono stati ancora inviati a un telecomando:
Assicurati di aver eseguito il commit o di aver archiviato tutte le modifiche correnti (cioè, in modo che non ci siano file elencati nella scheda "Stato file") - altrimenti non funzionerà.
Nella scheda "Log / Cronologia", fai clic con il pulsante destro del mouse sulla voce con una riga adiacente nel grafico sotto i commit che desideri modificare e seleziona "Rebase children of  interactive ..."
Seleziona l'intera riga per un messaggio di commit che desideri modificare (fai clic sulla colonna "Messaggio").
Fare clic sul pulsante "Modifica messaggio".
Modificare il messaggio come desiderato nella finestra di dialogo visualizzata, quindi fare clic su OK.
Ripetere i passaggi 3-4 se sono presenti altri messaggi di commit da modificare.
Fare clic su OK: inizierà il rebase. Se tutto va bene, l'output terminerà con "Completato con successo". NOTA: a volte ho visto questo errore con Impossibile creare "project_path / .git / index.lock": il file esiste. quando si tenta di modificare più messaggi di commit contemporaneamente. Non sono sicuro di quale sia il problema o se verrà risolto in una versione futura di Sourcetree, ma se ciò accadesse consiglierei di ribasarli uno alla volta (più lento ma sembra più affidabile).
... Oppure ... per i commit che sono già stati inviati:
Segui i passaggi in questa risposta, che sono simili a sopra, ma richiedono un ulteriore comando da eseguire dalla riga di comando (git push origin  -f) per forzare il push del ramo. Consiglierei di leggerlo tutto e di applicare la necessaria cautela!
|
Se vuoi solo modificare l'ultimo commit, usa:
git commit --amend
o
git commit --amend -m 'messaggio di una riga'
Ma se vuoi modificare più commit di seguito, dovresti invece usare il rebasing:
git rebase -i 
In un file, come quello sopra, scrivi modifica / e o una delle altre opzioni e premi salva ed esci.
Ora sarai al primo commit sbagliato. Apporta modifiche ai file e verranno automaticamente organizzate per te. genere
git commit --amend
Salva ed esci e digita
git rebase --continue
per passare alla selezione successiva fino al termine di tutte le selezioni.
Nota che queste cose cambiano tutti i tuoi hash SHA dopo quel particolare commit.
|
Se vuoi cambiare solo l'ultimo messaggio dovresti usare il flag --only o la sua scorciatoia -o con commit --amend:
git commit --amend -o -m "Nuovo messaggio di commit"
Questo ti assicura di non migliorare accidentalmente il tuo impegno con cose organizzate. Ovviamente è meglio avere una corretta configurazione di $ EDITOR. Quindi puoi lasciare l'opzione -m fuori e Git pre-riempirà il messaggio di commit con quello vecchio. In questo modo può essere facilmente modificato.
|
Aggiorna il tuo ultimo messaggio di commit sbagliato con il nuovo messaggio di commit in una riga:
git commit --amend -m "il tuo nuovo messaggio di commit"
Oppure prova a ripristinare Git come di seguito:
# Puoi reimpostare la tua testa su n numero di commit
# NON è una buona idea per cambiare l'ultimo messaggio di commit,
# ma puoi avere un'idea di dividere il commit in più commit
git reset --soft HEAD ^
# Ripristinerà l'ultimo commit. Ora tu
# può eseguire nuovamente il commit con un nuovo messaggio di commit.
Utilizzo di reset per dividere i commit in commit più piccoli
git reset può aiutarti a suddividere un commit in più commit:
# Ripristina la testa. Sto ripristinando gli ultimi commit:
git reset --soft HEAD ^
# (Puoi resettare più commit eseguendo HEAD ~ 2 (numero di commit)
# Ora, reimposta la testa persuddividendolo in più commit
git resetta HEAD
# Aggiungi e salva i tuoi file separatamente per fare più commit: ad es
git aggiungi app /
git commit -m "aggiungi tutti i file nella directory dell'app"
git aggiungi config /
git commit -m "aggiungi tutti i file nella directory di configurazione"
Qui hai suddiviso con successo il tuo ultimo commit in due commit.
|
Su questa domanda ci sono molte risposte, ma nessuna di esse spiega in dettaglio come cambiare i messaggi di commit più vecchi usando Vim. Ero bloccato nel provare a farlo da solo, quindi qui scriverò in dettaglio come l'ho fatto specialmente per le persone che non hanno esperienza in Vim!
Volevo modificare i miei ultimi cinque commit che ho già inviato al server. Questo è abbastanza "pericoloso" perché se qualcun altro ha già tirato fuori da questo, puoi rovinare le cose cambiando i messaggi di commit. Tuttavia, quando lavori sul tuo rametto e sei sicuro che nessuno lo abbia tirato, puoi cambiarlo in questo modo:
Supponiamo che tu voglia modificare i tuoi ultimi cinque commit e quindi digiti questo nel terminale:
git rebase -i HEAD ~ 5
* Dove 5 è il numero di messaggi di commit che desideri modificare (quindi se vuoi cambiare il decimo all'ultimo commit, digita 10).
Questo comando ti porterà in Vim dove puoi "modificare" la cronologia dei commit. Vedrai i tuoi ultimi cinque commit in alto in questo modo:
selezionare  messaggio di commit
Invece di scegliere devi scrivere una riformulazione. Puoi farlo in Vim digitando i. Questo ti fa entrare in modalità di inserimento. (Vedi che sei in modalità di inserimento dalla parola INSERT in basso). Per i commit che desideri modificare, digita reword invece di pick.
Quindi è necessario salvare e chiudere questa schermata. Puoi farlo andando prima in "modalità di comando" premendo il pulsante Esc (puoi verificare di essere in modalità di comando se la parola INSERT in basso è scomparsa). Quindi puoi digitare un comando digitando:. Il comando per salvare ed uscire è wq. Quindi se digiti: wq sei sulla strada giusta.
Quindi Vim esaminerà ogni messaggio di commit che vuoi riformulare, e qui puoi effettivamente cambiare i messaggi di commit. Lo farai entrando in modalità di inserimento, cambiando il messaggio di commit, entrando in modalità di comando, quindi salva ed esci. Fallo cinque volte e sei fuori da Vim!
Quindi, se hai già eseguito il push dei commit sbagliati, devi utilizzare git push --force per sovrascriverli. Ricorda che git push --force è una cosa abbastanza pericolosa da fare, quindi assicurati che nessuno si sia ritirato dal server da quando hai inserito i tuoi commit sbagliati!
Ora hai cambiato i tuoi messaggi di commit!
(Come vedi, non sono così esperto in Vim, quindi se ho usato il 'gergo' sbagliato per spiegare cosa sta succedendo, sentiti libero di correggermi!)
|
Puoi usare git-rebase-reword
È progettato per modificare qualsiasi commit (non solo l'ultimo) allo stesso modo di commit --amend
$ git rebase-reword 
Prende il nome dall'azione su rebase interactive per modificare un commit: "reword". Vedi questo post e man -section modalità interattiva-
Esempi:
$ git rebase-reword b68f560
$ git rebase-reword HEAD ^
|
Ho aggiunto gli alias reci e recm per riavviarlo (modificarlo). Ora posso farlo con git recm o git recm -m:
$ vim ~ / .gitconfig
[alias]
......
cm = commit
reci = commit --amend
recm = commit --amend
......
|
Mi sono reso conto che avevo spinto un commit con un errore di battitura. Per annullare, ho fatto quanto segue:
git commit --amend -m "T-1000, prototipo avanzato"
git push --force
Attenzione: forzare il push delle modifiche sovrascriverà il ramo remoto con quello locale. Assicurati di non sovrascrivere nulla che desideri conservare. Fai anche attenzione a forzare un commit modificato (riscritto) se qualcun altro condivide il ramo con te, perché dovrà riscrivere la propria cronologia se ha la vecchia copia del commit che hai appena riscritto.
|
Mi piace usare quanto segue:
stato git
git add --all
git commit -am "il messaggio va qui sul cambiamento"
git pull 
git push 
|
Se non hai inviato il codice al tuo ramo remoto (GitHub / Bitbucket) puoi modificare il messaggio di commit sulla riga di comando come sotto.
git commit --amend -m "Il tuo nuovo messaggio"
Se stai lavorando su un ramo specifico, fai questo:
git commit --amend -m "BRANCH-NAME: nuovo messaggio"
Se hai già inserito il codice con il messaggio sbagliato e devi fare attenzione quando cambi il messaggio. Cioè, dopo aver modificato il messaggio di commit e aver provato a spingerlo di nuovo, si finisce per avere problemi. Per renderlo fluido, segui questi passaggi.
Si prega di leggere tutta la mia risposta prima di farlo.
git commit --amend -m "BRANCH-NAME: il tuo nuovo messaggio"
git push -f origin BRANCH-NAME # Non è una best practice. Leggi di seguito perché?
Nota importante: quando si utilizza direttamente il push forzato, si potrebbero riscontrare problemi di codice che altri sviluppatori stanno lavorando sullo stesso ramo. Quindi, per evitare questi conflitti, è necessario estrarre il codice dal ramo prima di eseguire la forzaturaspingere:
git commit --amend -m "BRANCH-NAME: il tuo nuovo messaggio"
git pull origin BRANCH-NAME
git push -f origin BRANCH-NAME
Questa è la procedura migliore quando si modifica il messaggio di commit, se era già stato inviato.
|
Non è la risposta che stai cercando? Sfoglia altre domande contrassegnate con git git-commit git-rewrite-history modify o fai la tua domanda.